
// 数组归约运算
// type Fn = (accum:number , curr:number)=> number;

// function reduce(nums: number[], fn: Fn, init: number): number {
//     for( let key  of nums ){
//         init = fn(init,key)
        
//     }
//     return init;
// };

// const nums = [1,2,3,4]
// const fn = function sum(accum:number , curr:number) { return accum + curr; }
// const init = 100
// console.log(reduce(nums,fn,init),init);

// 复合函数

// type F = (x: number) => number;

// function compose(functions: F[]): F {
// 	return function(x) {
//         // 第一次执行回调函数时，不存在“上一次的计算结果”。如果需要回调函数从数组索引为 0 的元素开始执行，则需要传递初始值。
//         // 否则，数组索引为 0 的元素将被用作初始值，迭代器将从第二个元素开始执行（即从索引为 1 而不是 0 的位置开始）。
//         return functions.reduceRight((init,fn)=>fn(init),x)
//     }
// };


// const fn = compose([x => x + 1, x => 2 * x])
// console.log(fn(4));

// 过滤数组中的元素
// type Fn = (n: number, i: number) => any

// function filter(arr: number[], fn: Fn): number[] {
//     // 注意数组的定义格式
//     let result:number[] =[];
//     arr.forEach((item,index)=>{
//         if(fn(item,index)){
//             result.push(item);
//         }
//     })
//     return result;
// };

// console.log(filter([0,10,20,30],function greaterThan10(n) { return n > 10; }));


// 转换数组中的每个元素

// function map(arr: number[], fn: (n: number, i: number) => number): number[] {
//     let result : number[] = [];
//     arr.forEach((i,index)=>{
//         result.push(fn(i,index))
//     })
//     return result;
// };

// console.log(map([1,2,3],function plusone(n) { return n + 1; }));


// 生成斐波那契数列

function* fibGenerator(): Generator<number, any, number> {
    
};

/**
 * const gen = fibGenerator();
 * gen.next().value; // 0
 * gen.next().value; // 1
 */
